package hehe.container.definition;

import hehe.container.Container;
import hehe.container.build.xml.tag.Tag;
import hehe.container.definition.node.Node;
import hehe.container.util.ContainerUtil;
import java.util.HashMap;
import java.util.List;
import java.util.Map;


/**
 * bean节点对象
 *<B>说明：</B>
 *<pre>
 * 略
 *</pre>
 *<B>示例：</B>
 *<pre>
 *  略
 *</pre>
 *<B>日志：</B>
 *<pre>
 *  略
 *</pre>
 *<B>注意事项：</B>
 *<pre>
 *  略
 *</pre>
 */
public class Element
{

    public static String packageName;

    private String NAME_ELEMENT_SUFFIX = "Node";

    /**
     * 当前节点的属性
     *<B>说明：</B>
     *<pre>
     * 基本格式
     * {id="",name="", hasNode="" tagName=attr,ref="",class="",value=1201011}
     *</pre>
     */
    protected Map<String,Object> attrs = new HashMap<>();

    public Element()
    {

    }

    public Element(String name)
    {
        this.attrs.put(Tag.NAME_ATTRIBUTE,name);
    }

    /**
     * 构造方法
     *<B>说明：</B>
     *<pre>
     *  略
     *</pre>
     * @param attrs 节点属性
     */
    public Element(Map<String,Object> attrs)
    {
        this.attrs = attrs;
    }

    /**
     * 创建节点对象
     * <B>说明：</B>
     *<pre>
     *  略
     *</pre>
     * @param attrs
     * @return
     */
    public static Element make(Map<String,Object> attrs)
    {
        return new Element(attrs);
    }

    /**
     * 是否存在指定属性
     *<B>说明：</B>
     *<pre>
     * 略
     *</pre>
     */
    public boolean hasAttribute(String attrName)
    {
        if (this.attrs.containsKey(attrName)) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * 获取属性值
     *<B>说明：</B>
     *<pre>
     * 略
     *</pre>
     */
    public String getAttribute(String attrName)
    {
        return (String)this.attrs.get(attrName);
    }

    /**
     * 设置属性值
     *<B>说明：</B>
     *<pre>
     *  略
     *</pre>
     */
    public void setAttribute(String attrName,Object attrValue)
    {
        this.attrs.put(attrName,attrValue);
    }

    /**
     * 获取属性名
     *<B>说明：</B>
     *<pre>
     * 略
     *</pre>
     */
    public String getName()
    {
        return this.getAttribute(Tag.NAME_ATTRIBUTE);
    }

    /**
     * 获取属性类型
     *<B>说明：</B>
     *<pre>
     * 略
     *</pre>
     */
    public boolean isType(String type)
    {
        if (this.getAttribute(Tag.NODENAME_ATTRIBUTE).equals(type)) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * 判断是否有子节点
     *<B>说明：</B>
     *<pre>
     *  略
     *</pre>
     * @return boolean
     */
    public boolean hasNode()
    {
        if (this.attrs.containsKey(Tag.HASHNODE_ATTRIBUTE) && ((boolean)this.attrs.get(Tag.HASHNODE_ATTRIBUTE))) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * 获取子节点对象
     *<B>说明：</B>
     *<pre>
     *  略
     *</pre>
     * @return boolean
     */
    public Object getChildNode()
    {
        return this.attrs.get(Tag.VALUE_ATTRIBUTE);
    }


    /**
     * 创建节点对象
     *<B>说明：</B>
     *<pre>
     *  略
     *</pre>
     * @return boolean
     */
    public Node makeNode()
    {
        String nodeName = this.getAttribute(Tag.NODENAME_ATTRIBUTE);
        try {
            nodeName = this.getPackageName()  + ".node." + ContainerUtil.upperCase(nodeName) + NAME_ELEMENT_SUFFIX;
            Class <?> cls = Class.forName(nodeName) ;
            Node node = (Node)cls.newInstance(); //调用无参构造
            return node;
        } catch (ClassNotFoundException ex) {
            return new Node();
        } catch (Exception ex) {
            return null;
        }
    }

    /**
     * 获取bean 属性
     *<B>说明：</B>
     *<pre>
     *  实例化bean 时调用
     *</pre>
     * @return Object
     */
    public Object getValue()
    {
        if (this.hasNode()) {

            // 如果有class 属性,并且有子节点,则直接创建改对象
            if (this.attrs.containsKey(Tag.CLASS_ATTRIBUTE)) {
                return Container.getContainer().getBean(this.attrs);
            }

            List<Map<String,Object>> childNode = (List<Map<String,Object>>)this.getChildNode();
            if (childNode.size() > 0) {
                // 创建当前节点对象
                Element nodeEle = Element.make(childNode.get(0));
                Node node = nodeEle.makeNode();
                return node.parse(nodeEle);
            } else {
                return null;
            }
        } else {
            return this.parseValue();
        }
    }

    /**
     * 获取节点value值
     *<B>说明：</B>
     *<pre>
     *  无子节点属性值
     *</pre>
     */
    public Object parseValue()
    {
        // bean 对象
        if (this.attrs.containsKey(Tag.REF_ATTRIBUTE)) {
            return Container.getContainer().getBean((String)this.attrs.get(Tag.REF_ATTRIBUTE));
        }

        // 普通类对象,直接实例化对象
        if (this.attrs.containsKey(Tag.CLASS_ATTRIBUTE)) {
            return Container.getContainer().makeBean((String)this.attrs.get(Tag.CLASS_ATTRIBUTE));
        }

        // 普通类型
        return this.attrs.get(Tag.VALUE_ATTRIBUTE);
    }

    /**
     * 获取当前类包名
     *<B>说明：</B>
     *<pre>
     * 　略
     *</pre>
     * @return 当前包名
     */
    public String getPackageName()
    {
        if (packageName == null) {
            // 获取当前类的包名（不包含自己）
            packageName = new Object()    {
                public String getPackageName()
                {
                    Class onwClass = this.getClass();
                    Package dbPackage =  onwClass.getPackage();
                    return  dbPackage.getName();
                }
            }.getPackageName();
        }

        return packageName;
    }

}
